var UTILS = {
    /**
     * 数组去重
     * @param {Array} arr
     */
    uniqueArray: function (arr) {
        var unique = {};
        var result = [];
        for (var j = 0; j < arr.length; j++) {
            var c = arr[j];
            if (!unique[c]) {
                unique[c] = true;
                result.push(c);
            }
        }
        return result;
    },

    /**
     * 判断两个颜色是否匹配
     * @param {*} color1
     * @param {*} color2
     * @param {*} tolerance
     */
    isColorMatch: function (color1, color2, tolerance) {
        // 添加空值检查
        if (!color1 || !color2) return false;

        // 设置默认容差值
        tolerance = tolerance || 0;

        // 检查颜色类型
        if (color1.typename !== color2.typename) {
            // 如果是专色，获取其实际颜色进行比较
            if (color1.typename === "SpotColor") {
                return UTILS.isColorMatch(color1.spot.color, color2, tolerance);
            }
            if (color2.typename === "SpotColor") {
                return UTILS.isColorMatch(color1, color2.spot.color, tolerance);
            }
            return false;
        }

        // 根据颜色类型进行比较
        switch (color1.typename) {
            case "CMYKColor":
                return (
                    Math.abs(color1.cyan - color2.cyan) <= tolerance &&
                    Math.abs(color1.magenta - color2.magenta) <= tolerance &&
                    Math.abs(color1.yellow - color2.yellow) <= tolerance &&
                    Math.abs(color1.black - color2.black) <= tolerance
                );

            case "RGBColor":
                return Math.abs(color1.red - color2.red) <= tolerance && Math.abs(color1.green - color2.green) <= tolerance && Math.abs(color1.blue - color2.blue) <= tolerance;

            case "GrayColor":
                return Math.abs(color1.gray - color2.gray) <= tolerance;

            case "SpotColor":
                return UTILS.isColorMatch(color1.spot.color, color2.spot.color, tolerance);

            default:
                return false;
        }
    },

    /**
     * 获取颜色文本
     * @param {*} color
     */
    getColorText: function (color) {
        if (color.typename === "RGBColor") {
            return "RGB(" + color.red + ", " + color.green + ", " + color.blue + ")";
        } else if (color.typename === "CMYKColor") {
            return "CMYK(" + color.cyan + ", " + color.magenta + ", " + color.yellow + ", " + color.black + ")";
        } else if (color.typename === "GrayColor") {
            return "Gray(" + color.gray + ")";
        } else if (color.typename === "SpotColor") {
            return "SpotColor(" + color.spot.name + ")";
        } else if (color.typename === "PatternColor") {
            return "PatternColor(" + color.pattern.name + ")";
        }

        return null;
    },

    /**
     * 输出对象所有属性
     * @param {*} obj
     */
    printProperties: function (obj) {
        for (var prop in obj) {
            $.writeln(prop + ": " + obj[prop]);
        }
    },

    /**
     * 获取颜色
     * @param {*} obj 对象
     * @returns {Array} 颜色数组
     */
    getColors: function (obj) {
        var colors = [];

        function collectColors(item) {
            if (item.typename === "GroupItem") {
                for (var i = 0; i < item.pageItems.length; i++) {
                    collectColors(item.pageItems[i]);
                }
            } else if (item.typename === "CompoundPathItem" && item.pathItems.length > 0) {
                // 修复：先检查pathItems是否为空
                for (var i = 0; i < item.pathItems.length; i++) {
                    collectColors(item.pathItems[i]);
                }
            } else {
                if (item.filled && item.fillColor) {
                    addColor(item.fillColor);
                }
                // 同时收集描边颜色
                if (item.stroked && item.strokeColor) {
                    addColor(item.strokeColor);
                }
            }
        }

        function addColor(color) {
            if (color.typename === "RGBColor") {
                colors.push("RGB(" + Math.round(color.red) + ", " + Math.round(color.green) + ", " + Math.round(color.blue) + ")");
            } else if (color.typename === "CMYKColor") {
                colors.push("CMYK(" + Math.round(color.cyan) + ", " + Math.round(color.magenta) + ", " + Math.round(color.yellow) + ", " + Math.round(color.black) + ")");
            } else if (color.typename === "GrayColor") {
                colors.push("Gray(" + Math.round(color.gray) + ")");
            } else if (color.typename === "SpotColor") {
                colors.push("SpotColor(" + color.spot.name + ")");
            } else if (color.typename === "PatternColor") {
                colors.push("PatternColor(" + color.pattern.name + ")");
            } else if (color.typename === "GradientColor") {
                // 处理渐变色，提取渐变中的关键颜色
                var gradientStops = color.gradient.gradientStops;
                for (var j = 0; j < gradientStops.length; j++) {
                    addColor(gradientStops[j].color);
                }
            }
        }

        collectColors(obj);

        return UTILS.uniqueArray(colors);
    },

    /**
     * 设置颜色
     * @param {*} obj 对象
     * @param {*} color 颜色
     */
    setColor: function (obj, color) {
        function collectColors(item) {
            if (item.typename === "GroupItem") {
                for (var i = 0; i < item.pageItems.length; i++) {
                    collectColors(item.pageItems[i]);
                }
            } else if (item.typename === "CompoundPathItem") {
                for (var i = 0; i < item.pathItems.length; i++) {
                    collectColors(item.pathItems[i]);
                }
            } else {
                item.filled = true; // 确保填充为true
                item.fillColor = color; // 设置填充颜色
                item.stroked = false; // 确保不描边
            }
        }

        collectColors(obj);
    },

    /**
     * 获取选区的颜色
     */
    getSelectionColors: function () {
        var items = app.activeDocument.selection;
        if (items.length === 0) {
            alert("No items selected.");
            return [];
        }

        var allColors = [];
        for (var i = 0; i < items.length; i++) {
            var colors = UTILS.getColors(items[i]);
            allColors = allColors.concat(colors);
        }

        return UTILS.uniqueArray(allColors);
    },

    /**
     * 获取文档中所有的颜色
     */
    getAllColorsByDoc: function (doc) {
        var doc = doc || app.activeDocument;
        var items = doc.pathItems;
        if (items.length === 0) {
            alert("No items selected.");
            return [];
        }
        var allColors = [];
        for (var i = 0; i < items.length; i++) {
            var colors = UTILS.getColors(items[i]);
            allColors = allColors.concat(colors);
        }

        return UTILS.uniqueArray(allColors);
    },

    /**
     * 获取选区的金属颜色
     * @param {boolean} isRaised 是否只获取凸起的金属颜色
     * @returns {Array} 金属颜色数组
     */
    getSelectionMetalColors: function (isRaised) {
        var items = app.activeDocument.selection;
        if (items.length === 0) {
            alert("No items selected.");
            return [];
        }

        var selectionColors = UTILS.getSelectionColors().map(function (color) {
            color = color
                .replace(/^RGB\(/, "")
                .replace(/^CMYK\(/, "")
                .replace(/^Gray\(/, "")
                .replace(/^SpotColor\(/, "")
                .replace(/^PatternColor\(/, "");
            color = color.replace(/\)$/, "").trim();
            return color;
        });
        var metalColors = CFG.metalColors.map(function (color) {
            return color.name;
        });
        if (isRaised) {
            metalColors = CFG.metalColors
                .filter(function (color) {
                    return color.isRaised;
                })
                .map(function (color) {
                    return color.name;
                });
        }
        var selectedMetalColors = selectionColors.filter(function (color) {
            return metalColors.includes(color);
        });

        return selectedMetalColors;
    },

    /**
     * 获取选区的颜色分组
     */
    getSelectionColorGroups: function () {
        var items = app.activeDocument.selection;
        if (items.length === 0) {
            alert("No items selected.");
            return null;
        }
        var colorGroups = {};

        for (var i = 0; i < items.length; i++) {
            handle(items[i]);
        }

        function handle(item) {
            if (item.typename === "GroupItem") {
                for (var j = 0; j < item.pageItems.length; j++) {
                    handle(item.pageItems[j]);
                }
            } else if (item.typename === "CompoundPathItem" && item.pathItems[0].filled && item.pathItems[0].fillColor) {
                // 对于复合路径，处理第一个路径项
                var firstPathItem = item.pathItems[0];
                var colorKey = UTILS.getColorText(firstPathItem.fillColor);
                if (colorKey) {
                    if (!colorGroups[colorKey]) {
                        colorGroups[colorKey] = [];
                    }
                    colorGroups[colorKey].push(item);
                }
            } else if (item.typename === "PathItem") {
                if (item.filled && item.fillColor) {
                    var colorKey = UTILS.getColorText(item.fillColor);
                    if (colorKey) {
                        if (!colorGroups[colorKey]) {
                            colorGroups[colorKey] = [];
                        }
                        colorGroups[colorKey].push(item);
                    }
                }
            }
        }

        return colorGroups;
    },
};

// 从光栅图像中提取颜色信息（使用Illustrator支持的方法）
function extractColorsFromRaster(raster) {
    var result = [];

    try {
        // 创建临时文档
        var tempDoc = app.documents.add(DocumentColorSpace.RGB, raster.width, raster.height);

        // 复制图像到临时文档
        var tempRaster = raster.duplicate(tempDoc, ElementPlacement.PLACEATBEGINNING);
        tempRaster.position = [0, tempDoc.height];

        // 执行描摹并设置描摹选项以提高颜色准确性
        var pItem = tempRaster.trace();
        
        try {
            // 设置描摹选项来提高颜色识别准确性
            var tracingOptions = pItem.tracing.tracingOptions;
            
            // 使用兼容性更好的方式设置描摹选项
            if (typeof TracingColorTypeValue !== 'undefined') {
                tracingOptions.colorTypeValue = TracingColorTypeValue.TRACINGFULLCOLOR;
            }
            
            if (typeof TracingPaletteValue !== 'undefined') {
                tracingOptions.palette = TracingPaletteValue.TRACINGFULLCOLORPALETTE;
            }
            
            if (typeof TracingMethodValue !== 'undefined') {
                tracingOptions.tracingMethod = TracingMethodValue.TRACINGMETHODABUTTING;
            }
            
            // 基本数值设置（兼容性更好）
            tracingOptions.maxColors = 256; // 增加最大颜色数
            tracingOptions.colorFidelity = 85; // 设置颜色保真度（0-100）
            tracingOptions.grayLevels = 50; // 灰度级别
            tracingOptions.pathFidelity = 85; // 路径保真度
            tracingOptions.cornerFidelity = 85; // 拐角保真度
            tracingOptions.noiseFidelity = 20; // 噪点保真度
            tracingOptions.fills = true; // 创建填充
            tracingOptions.strokes = false; // 不创建描边
            tracingOptions.snapCurveToLines = false; // 不将曲线对齐到直线
            tracingOptions.ignoreWhite = true; // 忽略白色
            
            // 应用描摹选项
            pItem.tracing.tracingOptions = tracingOptions;
        } catch (optionError) {
            // 如果设置选项失败，使用默认选项
            $.writeln("描摹选项设置失败，使用默认选项: " + optionError.message);
        }

        // 扩展描摹结果
        pItem.tracing.expandTracing();

        result = UTILS.getAllColorsByDoc(tempDoc);

        // 关闭临时文档
        // tempDoc.close(SaveOptions.DONOTSAVECHANGES);
    } catch (e) {
        alert("提取颜色时出错: " + e.message + "\n行号: " + e.line);
    }

    return result;
}

// 改进的颜色提取函数，包含颜色合并功能
function extractColorsFromRasterWithMerging(raster, colorTolerance) {
    var rawColors = extractColorsFromRaster(raster);
    var tolerance = colorTolerance || 10; // 默认容差值
    
    // 将颜色字符串转换为颜色对象进行比较
    var colorObjects = [];
    for (var i = 0; i < rawColors.length; i++) {
        var colorStr = rawColors[i];
        var colorObj = parseColorString(colorStr);
        if (colorObj) {
            colorObjects.push({
                original: colorStr,
                parsed: colorObj
            });
        }
    }
    
    // 合并相似颜色
    var mergedColors = [];
    var used = [];
    
    for (var i = 0; i < colorObjects.length; i++) {
        if (used[i]) continue;
        
        var currentColor = colorObjects[i];
        var similarColors = [currentColor];
        used[i] = true;
        
        // 查找相似颜色
        for (var j = i + 1; j < colorObjects.length; j++) {
            if (used[j]) continue;
            
            if (areColorsSimilar(currentColor.parsed, colorObjects[j].parsed, tolerance)) {
                similarColors.push(colorObjects[j]);
                used[j] = true;
            }
        }
        
        // 选择最具代表性的颜色（可以是第一个或平均值）
        mergedColors.push(currentColor.original);
    }
    
    return mergedColors;
}

// 解析颜色字符串为颜色对象
function parseColorString(colorStr) {
    if (colorStr.indexOf('RGB(') === 0) {
        var values = colorStr.replace('RGB(', '').replace(')', '').split(', ');
        return {
            type: 'RGB',
            r: parseInt(values[0]),
            g: parseInt(values[1]),
            b: parseInt(values[2])
        };
    } else if (colorStr.indexOf('CMYK(') === 0) {
        var values = colorStr.replace('CMYK(', '').replace(')', '').split(', ');
        return {
            type: 'CMYK',
            c: parseFloat(values[0]),
            m: parseFloat(values[1]),
            y: parseFloat(values[2]),
            k: parseFloat(values[3])
        };
    }
    return null;
}

// 检查两个颜色是否相似
function areColorsSimilar(color1, color2, tolerance) {
    if (color1.type !== color2.type) return false;
    
    if (color1.type === 'RGB') {
        var rDiff = Math.abs(color1.r - color2.r);
        var gDiff = Math.abs(color1.g - color2.g);
        var bDiff = Math.abs(color1.b - color2.b);
        return rDiff <= tolerance && gDiff <= tolerance && bDiff <= tolerance;
    } else if (color1.type === 'CMYK') {
        var cDiff = Math.abs(color1.c - color2.c);
        var mDiff = Math.abs(color1.m - color2.m);
        var yDiff = Math.abs(color1.y - color2.y);
        var kDiff = Math.abs(color1.k - color2.k);
        return cDiff <= tolerance && mDiff <= tolerance && yDiff <= tolerance && kDiff <= tolerance;
    }
    
    return false;
}

function main() {
    try {
        var items = app.activeDocument.selection;
        if (items.length === 0) {
            return alert("No items selected.");
        }

        var image = items[0];

        $.writeln("Selected item: " + image.name + ", Type: " + image.typename);

        // 使用改进的颜色提取方法
        var rawColors = extractColorsFromRaster(image);
        $.writeln("原始提取到的颜色数量: " + rawColors.length);
        $.writeln("原始颜色: " + rawColors.join(", "));
        
        // 使用颜色合并功能减少相似颜色
        var mergedColors = extractColorsFromRasterWithMerging(image, 15); // 容差值15
        $.writeln("合并后的颜色数量: " + mergedColors.length);
        $.writeln("合并后的颜色: " + mergedColors.join(", "));

    } catch (error) {
        alert("脚本初始化错误: " + error.message + "\n行号: " + error.line);
    }
}

main();
